package main

import (
	"encoding/json"
	"fmt"
	"gameServer/config"
	"gameServer/config/filesource"
	"gameServer/etc/etc"
	"io/ioutil"
	"log"
	"os"
)

func main() {
	if err := etc.Init(); err != nil {
		fmt.Printf("配置初始化失败: %v\n", err)
		return
	}
	fmt.Println("配置初始化成功")
	configs := etc.GetGlobalConfig()
	fmt.Printf("加载配置数量: %d\n", len(configs))
	fmt.Println("===== etc配置功能测试 =====")

	// 获取配置路径
	configPath := getCurrentConfigPath()
	fmt.Printf("[调试] 配置路径: %s\n", configPath)

	// 初始化配置管理器
	// 创建文件配置源
	fileSource := filesource.NewFileSource(configPath, config.ReadOnly)
	// 使用WithSources将文件源添加到管理器
	manager := config.NewManager(config.WithSources(fileSource))
	// 设置为全局配置管理器
	etc.SetConfigManager(manager)

	// 验证配置文件是否存在
	if _, err := os.Stat(configPath); err != nil {
		fmt.Printf("[错误] 配置文件不存在: %v\n", err)
		return
	}

	// 打印配置文件内容
	printConfigFileContent(configPath)

	// 直接访问全局配置数据
	fmt.Println("\n[调试] 直接访问全局配置数据...")
	printGlobalConfigData()

	// 测试配置加载
	fmt.Println("\n[测试] 加载配置并验证内容...")
	printAllConfig()

	// 测试具体配置项访问
	fmt.Println("\n[测试] 访问具体配置项...")
	checkConfigItem("gate.server.addr")
	checkConfigItem("grpc.server_address")
	checkConfigItem("gate.log.level")

	// 测试模糊匹配
	fmt.Println("\n[测试] 模糊匹配配置项...")
	// 测试gate.*模糊匹配
	matcher := manager.Match("gate.*")
	gateResults := make(map[string]interface{})
	err := matcher.Scan(&gateResults)
	if err != nil {
		log.Printf("[结果] gate.* 匹配错误: %v", err)
	} else {
		log.Printf("[结果] gate.* 匹配 %d 项:", len(gateResults))
		for k, v := range gateResults {
			log.Printf("  %s: %v", k, v)
		}
	}

	// 测试grpc.*模糊匹配
	matcher = manager.Match("grpc.*")
	grpcResults := make(map[string]interface{})
	err = matcher.Scan(&grpcResults)
	if err != nil {
		log.Printf("[结果] grpc.* 匹配错误: %v", err)
	} else {
		log.Printf("[结果] grpc.* 匹配 %d 项:", len(grpcResults))
		for k, v := range grpcResults {
			log.Printf("  %s: %v", k, v)
		}
	}
}

// 获取配置路径
func getCurrentConfigPath() string {
	if envPath := os.Getenv("R_DUE_ETC"); envPath != "" {
		return envPath
	}
	return "etc/etc/etc_demo/config.json"
}

// 打印所有配置
func printAllConfig() {
	// 获取配置管理器实例
	manager := etc.GetConfigManager()
	if manager == nil {
		fmt.Println("[错误] 配置管理器未初始化")
		return
	}

	// 手动获取顶级配置键并展平
	results := make(map[string]interface{})
	collectTopLevelConfig(manager, results)

	if len(results) == 0 {
		fmt.Println("[结果] 配置为空")
		return
	}

	fmt.Printf("[结果] 找到 %d 个配置项:\n", len(results))
	for key, value := range results {
		fmt.Printf("  %s: %v\n", key, value)
	}
}

// 收集顶级配置并展平
func collectTopLevelConfig(manager config.ConfigManager, results map[string]interface{}) {
	// 已知顶级配置键
	topLevelKeys := []string{"gate", "grpc"}

	for _, key := range topLevelKeys {
		if manager.Has(key) {
			value := manager.Get(key).Value()
			collectConfigValues(value, key, results)
		}
	}
}

// 递归收集配置项到结果map
func collectConfigValues(data interface{}, prefix string, results map[string]interface{}) {
	if dataMap, ok := data.(map[string]interface{}); ok {
		for key, value := range dataMap {
			newPrefix := key
			if prefix != "" {
				newPrefix = prefix + "." + key
			}
			collectConfigValues(value, newPrefix, results)
		}
	} else if dataSlice, ok := data.([]interface{}); ok {
		for i, item := range dataSlice {
			newPrefix := fmt.Sprintf("%s[%d]", prefix, i)
			collectConfigValues(item, newPrefix, results)
		}
	} else {
		if prefix != "" {
			results[prefix] = data
		}
	}
}

// 检查单个配置项
func checkConfigItem(key string) {
	if etc.Has(key) {
		value := etc.Get(key).String()
		fmt.Printf("[结果] %s = %s\n", key, value)
	} else {
		fmt.Printf("[结果] %s 不存在\n", key)
	}
}

// 模糊匹配配置
func matchConfigs(pattern string) {
	matcher := etc.Match(pattern)
	results := make(map[string]interface{})
	if err := matcher.Scan(&results); err != nil {
		fmt.Printf("[错误] 匹配 %s 失败: %v\n", pattern, err)
		return
	}

	fmt.Printf("[结果] %s 匹配 %d 项:\n", pattern, len(results))
	for key, value := range results {
		fmt.Printf("  %s: %v\n", key, value)
	}
}

// 打印配置文件内容
func printConfigFileContent(path string) {
	fmt.Println("\n[调试] 配置文件内容:")
	content, err := ioutil.ReadFile(path)
	if err != nil {
		fmt.Printf("[错误] 读取配置文件失败: %v\n", err)
		return
	}

	// 格式化JSON输出
	var prettyJSON map[string]interface{}
	if err := json.Unmarshal(content, &prettyJSON); err != nil {
		fmt.Printf("[错误] 解析JSON失败: %v\n", err)
		fmt.Printf("原始内容: %s\n", content)
		return
	}

	formattedJSON, _ := json.MarshalIndent(prettyJSON, "  ", "  ")
	fmt.Println(string(formattedJSON))
}

// 打印全局配置数据
func printGlobalConfigData() {
	// 直接访问etc包的全局配置变量
	fmt.Printf("[调试] 全局配置数据长度: %d\n", len(etc.GetGlobalConfig()))
	for i, cfg := range etc.GetGlobalConfig() {
		fmt.Printf("[调试] 配置项 %d: %+v\n", i, cfg)
		content, _ := json.MarshalIndent(cfg.Content, "  ", "  ")
		fmt.Printf("[调试] 配置内容: %s\n", content)
	}
}
